home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-19 / gpt32src.zip / UTIL.C < prev    next >
C/C++ Source or Header  |  1992-03-25  |  13KB  |  609 lines
  1. #ifndef lint
  2. static char *RCSid = "$Id: util.c,v 3.26 92/03/24 22:34:43 woo Exp Locker: woo $";
  3. #endif
  4.  
  5. /* GNUPLOT - util.c */
  6. /*
  7.  * Copyright (C) 1986, 1987, 1990, 1991, 1992   Thomas Williams, Colin Kelley
  8.  *
  9.  * Permission to use, copy, and distribute this software and its
  10.  * documentation for any purpose with or without fee is hereby granted, 
  11.  * provided that the above copyright notice appear in all copies and 
  12.  * that both that copyright notice and this permission notice appear 
  13.  * in supporting documentation.
  14.  *
  15.  * Permission to modify the software is granted, but not the right to
  16.  * distribute the modified code.  Modifications are to be distributed 
  17.  * as patches to released version.
  18.  *  
  19.  * This software is provided "as is" without express or implied warranty.
  20.  * 
  21.  *
  22.  * AUTHORS
  23.  * 
  24.  *   Original Software:
  25.  *     Thomas Williams,  Colin Kelley.
  26.  * 
  27.  *   Gnuplot 2.0 additions:
  28.  *       Russell Lang, Dave Kotz, John Campbell.
  29.  *
  30.  *   Gnuplot 3.0 additions:
  31.  *       Gershon Elber and many others.
  32.  * 
  33.  * Send your comments or suggestions to 
  34.  *  info-gnuplot@ames.arc.nasa.gov.
  35.  * This is a mailing list; to join it send a note to 
  36.  *  info-gnuplot-request@ames.arc.nasa.gov.  
  37.  * Send bug reports to
  38.  *  bug-gnuplot@ames.arc.nasa.gov.
  39.  */
  40.  
  41. #include <ctype.h>
  42. #include <setjmp.h>
  43. #include <stdio.h>
  44. #include <errno.h>
  45. #include "plot.h"
  46.  
  47. BOOLEAN screen_ok;
  48.     /* TRUE if command just typed; becomes FALSE whenever we
  49.         send some other output to screen.  If FALSE, the command line
  50.         will be echoed to the screen before the ^ error message. */
  51.  
  52. #ifndef vms
  53. #ifndef __ZTC__
  54. extern int errno;
  55. extern int sys_nerr;
  56. extern char *sys_errlist[];
  57. #endif
  58. #endif /* vms */
  59.  
  60. extern char input_line[];
  61. extern struct lexical_unit token[];
  62. extern jmp_buf env;    /* from plot.c */
  63. extern int inline_num;        /* from command.c */
  64. extern BOOLEAN interactive;    /* from plot.c */
  65. extern char *infile_name;    /* from plot.c */
  66.  
  67. extern char *strchr();
  68.  
  69. #ifndef AMIGA_AC_5
  70. extern double sqrt(), atan2();
  71. #endif
  72.  
  73. /*
  74.  * chr_in_str() compares the characters in the string of token number t_num
  75.  * with c, and returns TRUE if a match was found.
  76.  */
  77. chr_in_str(t_num, c)
  78. int t_num;
  79. char c;
  80. {
  81. register int i;
  82.  
  83.     if (!token[t_num].is_token)
  84.         return(FALSE);                /* must be a value--can't be equal */
  85.     for (i = 0; i < token[t_num].length; i++) {
  86.         if (input_line[token[t_num].start_index+i] == c)
  87.             return(TRUE);
  88.         }
  89.     return FALSE;
  90. }
  91.  
  92.  
  93. /*
  94.  * equals() compares string value of token number t_num with str[], and
  95.  *   returns TRUE if they are identical.
  96.  */
  97. equals(t_num, str)
  98. int t_num;
  99. char *str;
  100. {
  101. register int i;
  102.  
  103.     if (!token[t_num].is_token)
  104.         return(FALSE);                /* must be a value--can't be equal */
  105.     for (i = 0; i < token[t_num].length; i++) {
  106.         if (input_line[token[t_num].start_index+i] != str[i])
  107.             return(FALSE);
  108.         }
  109.     /* now return TRUE if at end of str[], FALSE if not */
  110.     return(str[i] == '\0');
  111. }
  112.  
  113.  
  114.  
  115. /*
  116.  * almost_equals() compares string value of token number t_num with str[], and
  117.  *   returns TRUE if they are identical up to the first $ in str[].
  118.  */
  119. almost_equals(t_num, str)
  120. int t_num;
  121. char *str;
  122. {
  123. register int i;
  124. register int after = 0;
  125. register start = token[t_num].start_index;
  126. register length = token[t_num].length;
  127.  
  128.     if (!token[t_num].is_token)
  129.         return(FALSE);                /* must be a value--can't be equal */
  130.     for (i = 0; i < length + after; i++) {
  131.         if (str[i] != input_line[start + i]) {
  132.             if (str[i] != '$')
  133.                 return(FALSE);
  134.             else {
  135.                 after = 1;
  136.                 start--;    /* back up token ptr */
  137.                 }
  138.             }
  139.         }
  140.  
  141.     /* i now beyond end of token string */
  142.  
  143.     return(after || str[i] == '$' || str[i] == '\0');
  144. }
  145.  
  146.  
  147.  
  148. isstring(t_num)
  149. int t_num;
  150. {
  151.     
  152.     return(token[t_num].is_token &&
  153.            (input_line[token[t_num].start_index] == '\'' ||
  154.            input_line[token[t_num].start_index] == '\"'));
  155. }
  156.  
  157.  
  158. isnumber(t_num)
  159. int t_num;
  160. {
  161.     return(!token[t_num].is_token);
  162. }
  163.  
  164.  
  165. isletter(t_num)
  166. int t_num;
  167. {
  168.     return(token[t_num].is_token &&
  169.             ((isalpha(input_line[token[t_num].start_index]))||
  170.              (input_line[token[t_num].start_index] == '_')));
  171. }
  172.  
  173.  
  174. /*
  175.  * is_definition() returns TRUE if the next tokens are of the form
  176.  *   identifier =
  177.  *        -or-
  178.  *   identifier ( identifer ) =
  179.  */
  180. is_definition(t_num)
  181. int t_num;
  182. {
  183.     return (isletter(t_num) &&
  184.             (equals(t_num+1,"=") ||            /* variable */
  185.             (equals(t_num+1,"(") &&        /* function */
  186.              isletter(t_num+2)   &&
  187.              equals(t_num+3,")") &&
  188.              equals(t_num+4,"=") ) ||
  189.             (equals(t_num+1,"(") &&        /* function with */
  190.              isletter(t_num+2)   &&        /* two variables */
  191.              equals(t_num+3,",") &&
  192.              isletter(t_num+4)   &&
  193.              equals(t_num+5,")") &&
  194.              equals(t_num+6,"=") )
  195.         ));
  196. }
  197.  
  198.  
  199.  
  200. /*
  201.  * copy_str() copies the string in token number t_num into str, appending
  202.  *   a null.  No more than MAX_ID_LEN chars are copied.
  203.  */
  204. copy_str(str, t_num)
  205. char str[];
  206. int t_num;
  207. {
  208. register int i = 0;
  209. register int start = token[t_num].start_index;
  210. register int count;
  211.  
  212.     if ((count = token[t_num].length) > MAX_ID_LEN)
  213.         count = MAX_ID_LEN;
  214.     do {
  215.         str[i++] = input_line[start++];
  216.         } while (i != count);
  217.     str[i] = '\0';
  218. }
  219.  
  220.  
  221. /*
  222.  * quote_str() does the same thing as copy_str, except it ignores the
  223.  *   quotes at both ends.  This seems redundant, but is done for
  224.  *   efficency.
  225.  */
  226. quote_str(str, t_num)
  227. char str[];
  228. int t_num;
  229. {
  230. register int i = 0;
  231. register int start = token[t_num].start_index + 1;
  232. register int count;
  233.  
  234.     if ((count = token[t_num].length - 2) > MAX_ID_LEN)
  235.         count = MAX_ID_LEN;
  236.     if (count>0) {
  237.         do {
  238.             str[i++] = input_line[start++];
  239.             } while (i != count);
  240.     }
  241.     str[i] = '\0';
  242. }
  243.  
  244.  
  245. /*
  246.  * quotel_str() does the same thing as quote_str, except it uses
  247.  * MAX_LINE_LEN instead of MAX_ID_LEN. 
  248.  */ 
  249. quotel_str(str, t_num) 
  250. char str[]; 
  251. int t_num; 
  252. {
  253. register int i = 0;
  254. register int start = token[t_num].start_index + 1;
  255. register int count;
  256.  
  257.     if ((count = token[t_num].length - 2) > MAX_LINE_LEN)
  258.         count = MAX_LINE_LEN;
  259.     if (count>0) {
  260.         do {
  261.             str[i++] = input_line[start++];
  262.             } while (i != count);
  263.     }
  264.     str[i] = '\0';
  265. }
  266.  
  267.  
  268. /*
  269.  *    capture() copies into str[] the part of input_line[] which lies between
  270.  *    the begining of token[start] and end of token[end].
  271.  */
  272. capture(str,start,end)
  273. char str[];
  274. int start,end;
  275. {
  276. register int i,e;
  277.  
  278.     e = token[end].start_index + token[end].length;
  279.     for (i = token[start].start_index; i < e && input_line[i] != '\0'; i++)
  280.         *str++ = input_line[i];
  281.     *str = '\0';
  282. }
  283.  
  284.  
  285. /*
  286.  *    m_capture() is similar to capture(), but it mallocs storage for the
  287.  *  string.
  288.  */
  289. m_capture(str,start,end)
  290. char **str;
  291. int start,end;
  292. {
  293. register int i,e;
  294. register char *s;
  295.  
  296.     if (*str)        /* previous pointer to malloc'd memory there */
  297.         free(*str);
  298.     e = token[end].start_index + token[end].length;
  299.     *str = alloc((unsigned int)(e - token[start].start_index + 1), "string");
  300.      s = *str;
  301.      for (i = token[start].start_index; i < e && input_line[i] != '\0'; i++)
  302.       *s++ = input_line[i];
  303.      *s = '\0';
  304. }
  305.  
  306.  
  307. /*
  308.  *    m_quote_capture() is similar to m_capture(), but it removes
  309.     quotes from either end if the string.
  310.  */
  311. m_quote_capture(str,start,end)
  312. char **str;
  313. int start,end;
  314. {
  315. register int i,e;
  316. register char *s;
  317.  
  318.     if (*str)        /* previous pointer to malloc'd memory there */
  319.         free(*str);
  320.     e = token[end].start_index + token[end].length-1;
  321.     *str = alloc((unsigned int)(e - token[start].start_index + 1), "string");
  322.      s = *str;
  323.     for (i = token[start].start_index + 1; i < e && input_line[i] != '\0'; i++)
  324.      *s++ = input_line[i];
  325.     *s = '\0';
  326. }
  327.  
  328.  
  329. convert(val_ptr, t_num)
  330. struct value *val_ptr;
  331. int t_num;
  332. {
  333.     *val_ptr = token[t_num].l_val;
  334. }
  335.  
  336. static char *num_to_str(r)
  337. double r;
  338. {
  339.     static i = 0;
  340.     static char s[4][20];
  341.     int j = i++;
  342.  
  343.     if ( i > 3 ) i = 0;
  344.  
  345.     sprintf( s[j], "%g", r );
  346.     if ( strchr( s[j], '.' ) == NULL &&
  347.          strchr( s[j], 'e' ) == NULL &&
  348.          strchr( s[j], 'E' ) == NULL )
  349.         strcat( s[j], ".0" );
  350.  
  351.     return s[j];
  352. } 
  353.  
  354. disp_value(fp,val)
  355. FILE *fp;
  356. struct value *val;
  357. {
  358.     switch(val->type) {
  359.         case INT:
  360.             fprintf(fp,"%d",val->v.int_val);
  361.             break;
  362.         case CMPLX:
  363.             if (val->v.cmplx_val.imag != 0.0 )
  364.                 fprintf(fp,"{%s, %s}",
  365.                     num_to_str(val->v.cmplx_val.real),
  366.                     num_to_str(val->v.cmplx_val.imag));
  367.             else
  368.                 fprintf(fp,"%s",
  369.                     num_to_str(val->v.cmplx_val.real));
  370.             break;
  371.         default:
  372.             int_error("unknown type in disp_value()",NO_CARET);
  373.     }
  374. }
  375.  
  376.  
  377. double
  378. real(val)        /* returns the real part of val */
  379. struct value *val;
  380. {
  381.     switch(val->type) {
  382.         case INT:
  383.             return((double) val->v.int_val);
  384.         case CMPLX:
  385.             return(val->v.cmplx_val.real);
  386.     }
  387.     int_error("unknown type in real()",NO_CARET);
  388.     /* NOTREACHED */
  389.     return((double)0.0);
  390. }
  391.  
  392.  
  393. double
  394. imag(val)        /* returns the imag part of val */
  395. struct value *val;
  396. {
  397.     switch(val->type) {
  398.         case INT:
  399.             return(0.0);
  400.         case CMPLX:
  401.             return(val->v.cmplx_val.imag);
  402.     }
  403.     int_error("unknown type in imag()",NO_CARET);
  404.     /* NOTREACHED */
  405.     return((double)0.0);
  406. }
  407.  
  408.  
  409.  
  410. double
  411. magnitude(val)        /* returns the magnitude of val */
  412. struct value *val;
  413. {
  414.     switch(val->type) {
  415.         case INT:
  416.             return((double) abs(val->v.int_val));
  417.         case CMPLX:
  418.             return(sqrt(val->v.cmplx_val.real*
  419.                     val->v.cmplx_val.real +
  420.                     val->v.cmplx_val.imag*
  421.                     val->v.cmplx_val.imag));
  422.     }
  423.     int_error("unknown type in magnitude()",NO_CARET);
  424.     /* NOTREACHED */
  425.     return((double)0.0);
  426. }
  427.  
  428.  
  429.  
  430. double
  431. angle(val)        /* returns the angle of val */
  432. struct value *val;
  433. {
  434.     switch(val->type) {
  435.         case INT:
  436.             return((val->v.int_val > 0) ? 0.0 : Pi);
  437.         case CMPLX:
  438.             if (val->v.cmplx_val.imag == 0.0) {
  439.                 if (val->v.cmplx_val.real >= 0.0)
  440.                     return(0.0);
  441.                 else
  442.                     return(Pi);
  443.             }
  444.             return(atan2(val->v.cmplx_val.imag,
  445.                      val->v.cmplx_val.real));
  446.     }
  447.     int_error("unknown type in angle()",NO_CARET);
  448.     /* NOTREACHED */
  449.     return((double)0.0);
  450. }
  451.  
  452.  
  453. struct value *
  454. complex(a,realpart,imagpart)
  455. struct value *a;
  456. double realpart, imagpart;
  457. {
  458.     a->type = CMPLX;
  459.     a->v.cmplx_val.real = realpart;
  460.     a->v.cmplx_val.imag = imagpart;
  461.     return(a);
  462. }
  463.  
  464.  
  465. struct value *
  466. integer(a,i)
  467. struct value *a;
  468. int i;
  469. {
  470.     a->type = INT;
  471.     a->v.int_val = i;
  472.     return(a);
  473. }
  474.  
  475.  
  476.  
  477. os_error(str,t_num)
  478. char str[];
  479. int t_num;
  480. {
  481. #ifdef vms
  482. static status[2] = {1, 0};        /* 1 is count of error msgs */
  483. #endif
  484.  
  485. register int i;
  486.  
  487.     /* reprint line if screen has been written to */
  488.  
  489.     if (t_num != NO_CARET) {        /* put caret under error */
  490.         if (!screen_ok)
  491.             fprintf(stderr,"\n%s%s\n", PROMPT, input_line);
  492.  
  493.         for (i = 0; i < sizeof(PROMPT) - 1; i++)
  494.             (void) putc(' ',stderr);
  495.         for (i = 0; i < token[t_num].start_index; i++) {
  496.             (void) putc((input_line[i] == '\t') ? '\t' : ' ',stderr);
  497.             }
  498.         (void) putc('^',stderr);
  499.         (void) putc('\n',stderr);
  500.     }
  501.  
  502.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  503.         (void) putc(' ',stderr);
  504.     fprintf(stderr,"%s\n",str);
  505.  
  506.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  507.         (void) putc(' ',stderr);
  508.      if (!interactive)
  509.       if (infile_name != NULL)
  510.         fprintf(stderr,"\"%s\", line %d: ", infile_name, inline_num);
  511.       else
  512.         fprintf(stderr,"line %d: ", inline_num);
  513.  
  514.  
  515. #ifdef vms
  516.     status[1] = vaxc$errno;
  517.     sys$putmsg(status);
  518.     (void) putc('\n',stderr);
  519. #else
  520. #ifdef __ZTC__
  521.     fprintf(stderr,"error number %d\n\n",errno);
  522. #else
  523.     if (errno >= sys_nerr)
  524.         fprintf(stderr, "unknown errno %d\n\n", errno);
  525.     else
  526.         fprintf(stderr,"(%s)\n\n",sys_errlist[errno]);
  527. #endif
  528. #endif
  529.  
  530.     longjmp(env, TRUE);    /* bail out to command line */
  531. }
  532.  
  533.  
  534. int_error(str,t_num)
  535. char str[];
  536. int t_num;
  537. {
  538. register int i;
  539.  
  540.     /* reprint line if screen has been written to */
  541.  
  542.     if (t_num != NO_CARET) {        /* put caret under error */
  543.         if (!screen_ok)
  544.             fprintf(stderr,"\n%s%s\n", PROMPT, input_line);
  545.  
  546.         for (i = 0; i < sizeof(PROMPT) - 1; i++)
  547.             (void) putc(' ',stderr);
  548.         for (i = 0; i < token[t_num].start_index; i++) {
  549.             (void) putc((input_line[i] == '\t') ? '\t' : ' ',stderr);
  550.             }
  551.         (void) putc('^',stderr);
  552.         (void) putc('\n',stderr);
  553.     }
  554.  
  555.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  556.         (void) putc(' ',stderr);
  557.      if (!interactive)
  558.       if (infile_name != NULL)
  559.         fprintf(stderr,"\"%s\", line %d: ", infile_name, inline_num);
  560.       else
  561.         fprintf(stderr,"line %d: ", inline_num);
  562.      fprintf(stderr,"%s\n\n", str);
  563.  
  564.     longjmp(env, TRUE);    /* bail out to command line */
  565. }
  566.  
  567. /* Lower-case the given string (DFK) */
  568. /* Done in place. */
  569. void
  570. lower_case(s)
  571.      char *s;
  572. {
  573.   register char *p = s;
  574.  
  575.   while (*p != '\0') {
  576.     if (isupper(*p))
  577.      *p = tolower(*p);
  578.     p++;
  579.   }
  580. }
  581.  
  582. /* Squash spaces in the given string (DFK) */
  583. /* That is, reduce all multiple white-space chars to single spaces */
  584. /* Done in place. */
  585. void
  586. squash_spaces(s)
  587.      char *s;
  588. {
  589.   register char *r = s;        /* reading point */
  590.   register char *w = s;        /* writing point */
  591.   BOOLEAN space = FALSE;        /* TRUE if we've already copied a space */
  592.  
  593.   for (w = r = s; *r != '\0'; r++) {
  594.      if (isspace(*r)) {
  595.         /* white space; only copy if we haven't just copied a space */
  596.         if (!space) {
  597.             space = TRUE;
  598.             *w++ = ' ';
  599.         }                /* else ignore multiple spaces */
  600.      } else {
  601.         /* non-space character; copy it and clear flag */
  602.         *w++ = *r;
  603.         space = FALSE;
  604.      }
  605.   }
  606.   *w = '\0';                /* null terminate string */
  607. }
  608.  
  609.